
let title="月月赚";
let storage_name_key;
let fx_ty;  //移动方向   1：向上移除  默认   2：从下移除
/*****手机状态下的  基础值******/
let recents_depth_v;   /***depth的值情况*****/
let recents_id_v;      /****id的值情况****/
/********* */
let recents_zt_arr;   //recents状态验证 关键词

let  filter_temp_Obj=[];  //动态临时任务过滤对象  json格式存储  (方案1组合)
//[{"title":"每日打卡领现金","jg":"15话费币","ms":"无门槛秒到账"}]; 



let p_arr = ["去体验","去看看","去完成"];     //任务定位器
//"逛逛得奖励","浏览页面","逛逛页面","精选会场","看看页面"
let filter_arr=[""];  //任务过滤器 (不被执行任务)

let jh_list_arr=["完成一次机票查询","抽卡兑0元奖品","抽卡兑0元IP周边","逛一逛花呗亲情卡"]; //可执行任务【去完成中】

let ui_rw_main_arr=["赚更多转账红包","红包"];//确定任务界面关键词   多元素方案
 


let fz=true;
let ft=true;
let rw_list;     //任务列表
let rw_list_jg;  //奖励金额
let rw_list_title;//标题
let rw_list_ms;   //描述


let  filter_dt_t=true;  //动态过滤，增量
let rwtype;  //任务类型(通过检测器，检测任务类型)

let rw_list_obj_json={}; //json的任务对象




 


 app_main();


//【任务-启动器】启动任务
function  app_main(){
let run_z=false;
  try {
    device.keepScreenOn();//一直保持屏幕常亮  【有效】
    // device.cancelKeepingAwake();//来取消屏幕常亮。
  
 // toast("启动");
  initializeData();


  //加入首页判断
  ui_rw_RollBACK(1,["扫一扫","出行","卡包"],2,7);

  
  if(p_search_title(""+title,6)){
  console.info("进入了么");
 // sleep(6000);
  //验证是否进入制定页面
  for(let i=0;i<60;i++){
    if(p_Search_element_contains(1,ui_rw_main_arr)){
      run_z=true;
      break;
    }
    sleep(200);
  }



  if(run_z){
    p_app_zfb_collect_open(2);//收藏小程序
    

    
    sleep(1000);
  p_for_clear_div_main(10,0.1);
  for_clear_div_main(10,0.1);  //循环5轮，每轮停留1秒

   
  

   for(let i=0;i<5;i++){
    rw_main_run(); //执行
    sleep(2000);
    rw_next()
    }

  sleep(2000);
 
  


 sleep(2000);
 recents_romve_app_name(""+title,1,recents_zt_arr,0.5,2,fx_ty);   //移除完成的任务应用
 //关闭应用


  }
}


  //sleep(1000);
 // toast("结束了");
  console.info("任务结束");

  run_success();  //

} catch (error) {
  toast("网络异常");
  console.info("异常任务");
  run_error();
}finally{
 
}

}



/**********
 *  
 *    任务主方法
 * 
 */
function rw_main_run(){
  fz=true;

  let fileter_temp_s_obj=""; //动态临时任务过滤对象  string格式存储（方案3组合）
    //清除遮罩层
    p_for_clear_div_main(5,0.1);
    for_clear_div_main(5,0.1); 

    

while(fz){
  ft=true;
  
  //清除遮罩层
 // p_for_clear_div_main(5,0.1);
  for_clear_div_main(4,0.1); 


    /*********/
    rw_obj_search=p_hq_rw_Obj_init(p_arr);
    if(!(rw_obj_search && rw_obj_search.depth()>0)){
        toast("异常执行，结束任务");
        fz=false;
    }

    
  if(p_Search_element_contains(1,ui_rw_main_arr)){
      console.info("进入普通任务-start");
      rw_list=className(rw_obj_search.className()).depth(rw_obj_search.depth()).indexInParent(rw_obj_search.indexInParent()).enabled(true).find();//任务定位因子

    // rw_list=className("android.view.View").text("0.01元").enabled(true).find();//任务定位因子


    console.info("rw_obj_search.depth()="+rw_obj_search.depth());
    console.info("rw_obj_search.indexInParent()="+rw_obj_search.indexInParent());

  
      if(rw_list && rw_list.length>0){
          for(let i=0;i<rw_list.length;i++){
            filter_dt_t=true;
            console.info("[i]="+rw_list[i].parent().children().length);
              if(rw_list[i] && rw_list[i].parent() && rw_list[i].parent().parent() 
              && rw_list[i].parent().parent().children().length==4){
           
              
                 
                    //标题
                if(rw_list[i].parent().parent().children().length==4){
                  rw_list_title=rw_list[i].parent().parent().child(0).text();
                 }else{
                    rw_list_title="";
                 }


                  if(rw_list_title && rw_list_title.length>1){
                  
                  console.info("序号："+(i+1)+"|标题："+rw_list_title);
                  //sleep(2500);
                  if(p_filter_rwobj(rw_list_title)  ||  rw_list_title=="" ){
                    /***同时过滤空标题行****/
                    console.info("普通过滤器");
                    //过滤器 跳过本次循环
                    continue;
                  }


                     //拦截  过滤
                     if(rw_list[i] && rw_list[i].text() && rw_list[i].text()=="去完成"  
                     &&  !(jh_list_arr.indexOf(rw_list_title)>-1)){
                       console.info("去完成中过滤不执行任务的-过滤器");
                       continue;
                     }
    
              
                  
                    // 
                    if(rw_list[i].parent().parent().children().length==4){
                      rw_list_je=rw_list[i].parent().parent().child(2).text();
                      rw_list_ms=rw_list[i].parent().parent().child(1).text();
                   }else{
                    
                      rw_list_ms="";
                      rw_list_je="";
                   }
 


                   //动态过滤器
                   /****
                   rw_list_obj_json={"title":""+rw_list_title,"jg":""+rw_list_jg,"ms":""+rw_list_ms};
                   if(p_filter_temp_Obj_select(rw_list_obj_json)){
                     console.info("动态过滤器");
                     //过滤器 跳过本次循环
                     continue;
                   }*****/

                   
                     //动态过滤器 
                    
                    //动态过滤器 【方案3】
                    console.warn("【】="+fileter_temp_s_obj);
                    if(fileter_temp_s_obj.indexOf("|"+rw_list_title+"|")>-1){
                         console.info("string动态过滤器");
                      //过滤器 跳过本次循环
                      continue;
                    }



                  // toast("title"+""+rw_list_title+"|jg"+""+rw_list_jg+"|ms"+""+rw_list_ms);
                  // sleep(2500);
                    
                  //矫正位置  start
                    /********/
                    if(UImain_txt_correct(rw_list_title,2,8)){
                      console.info("普通任务——矫正了");
                      toast("矫正完成");
                      //  sleep(2000);
                       ft=false;
                      break;//通过重新取数
                    }
                    //矫正位置  end


                    
            /*****执行任务类型  分解******/
            if(p_Search_element_contains(1,ui_rw_main_arr)){
              /*****必须在可执行的界面中   必须在 “任务清单” 界面  *****/ 
                   console.info("执行点击事件");

                    
                   click(rw_list[i].bounds().centerX(),rw_list[i].bounds().centerY());
                 //  console.info("-----动态过滤器（增量）--------");
                   //p_filter_temp_Obj_add(rw_list_obj_json,2);  //增加动态过滤信息
                   /*****判定是否离开原界面****/
                  // if(ui_if_leave_interface(1,ui_rw_main_arr,0.1,30)){
                     console.info("判定界面离开");
                   
                   
                       /******
                      * 
                      * 任务类型检测器
                      *   1.通过关键词不断区搜索是否符合的条件
                      *   2.寻找到特定关键性词，就停止执行
                      */
                       rwtype=p_if_rwtype_detector(3,1);   //执行7轮，每次1秒



                     if(rwtype && rwtype=="tb_0"){
                      //阿里妈妈 视频广告与滑动广告任务
                      //execute_rw_slide();

                      let a1,a2;
                      let hd_zt_type=false;

                      for(let i=0;i<100;i++){
                        if(p_Search_element_contains(1,["商品展示由阿里妈妈提供技术支持"])){
                          a1=className("android.view.ViewGroup").enabled(true).findOnce();
                          a2=className("com.uc.webview.export.WebView").enabled(true).findOnce();
                          if(a1 && a2 && a1.className()=="android.view.ViewGroup" && a2.className()=="com.uc.webview.export.WebView"){
                            hd_zt_type=true;
                            break;
                          }
                        } 
                        sleep(1000);
                      }
                      if(hd_zt_type){
                        sleep(800);
                        execute_rw_shop_slide(18,0.4,["商品展示由阿里妈妈提供技术支持"]);
                        filter_dt_t=false;
                       }
                     }else if(rwtype && rwtype=="tb_1"){
                      //淘宝关注任务
                      if(!rw_taobao_gz(1,["好礼享不停","点击订阅店铺"],5,5)){
                        if(!(seek_app_All(""+title,fx_ty,5))){//返回失败
                          //强制停止
                          break;
                        }

                       }
                     }else if(rwtype && rwtype.indexOf("error_")>-1){
                      //无效任务
                      console.info("无效任务移除");
                     // seek_app_All(""+title,fx_ty,2);
                      if(!(seek_app_All(""+title,fx_ty,2))){//返回失败
                        //强制停止
                        break;
                      }
                     }else if(rwtype && rwtype=="ts_yyz_kpwj_0"){
                      //抽卡兑0元奖品  卡牌玩家
                      let djrwjd_if_zt=true;
                      for(let djrwjd_if_i=0;djrwjd_if_i<20;djrwjd_if_i++){
                        if(p_Search_element_contains(2,["剩余"])){
                          break;
                        }
                        if((p_Search_element_contains(2,["不足"]))){
                          djrwjd_if_zt=false;
                          break;
                        }
                        sleep(1000);
                      }

                      if(djrwjd_if_zt){
                        let djrwjd_obj;
                            djrwjd_obj=className("android.view.View").textContains("剩余").enabled(true).findOnce();
                            if(!(djrwjd_obj && djrwjd_obj.text().indexOf("剩余")>-1)){
                              djrwjd_obj=className("android.widget.TextView").textContains("剩余").enabled(true).findOnce();
                            }
                            if(!(djrwjd_obj && djrwjd_obj.text().indexOf("剩余")>-1)){
                              djrwjd_obj=className("android.widget.Button").textContains("剩余").enabled(true).findOnce();
                            }

                            if(djrwjd_obj && djrwjd_obj.text().indexOf("剩余")>-1){
                              click(djrwjd_obj.bounds().centerX(),djrwjd_obj.bounds().centerY());
                              //sleep(2000);
                              sleep(800);   
                            }
                      }

                      if(!(seek_app_All(""+title,fx_ty,2))){//返回失败
                        //P强制停止
                        break;
                      }

                     }else  if(rwtype && rwtype=="ts_yyz_cxjp_0"){
                      //完成一次急迫查询
                      let djrwjd_if_zt=false;
                      for(let djrwjd_if_i=0;djrwjd_if_i<20;djrwjd_if_i++){
                        if(p_Search_element_contains(1,["机票","出行"])){
                          djrwjd_if_zt=true;
                          break;
                        }                       
                        sleep(1000);
                      }

                      if(djrwjd_if_zt){           
                              sleep(2500);        
                          click((device.width/10)*5,(device.height/20)*13.4);       
                          sleep(800);                   
                      }

                      if(!(seek_app_All(""+title,fx_ty,2))){//返回失败
                        //P强制停止
                        break;
                      }
                      
                     }else{
                      //其他  移除任务
                      console.info("判定移除任务");
                     // seek_app_All(""+title,fx_ty,8);
                      if(!(seek_app_All(""+title,fx_ty,2))){//返回失败
                        //强制停止
                        break;
                      }
                     }


                    
 

                    // sleep(1500);
                    //sleep(3000);
                    console.info("返回寻找目标");

                   
                    ui_rw_RollBACK(1,ui_rw_main_arr,2,5);
                    //判断是否有出现
                    if(p_Search_element_contains(1,["恭喜获得","立即使用"]) ){
                      filter_dt_t=true;
                    }
                    
                    if(p_Search_element_contains(1,["领取的金币·红包 - 在【我的金币】可见","我知道了"]) ){
                      filter_dt_t=false;
                    }


                    ft=false;
                    if(filter_dt_t){//判断是否可以增量
                      console.info("-----动态过滤器（增量）--------");
                      fileter_temp_s_obj=fileter_temp_s_obj+"|"+rw_list_title+"|";  //增加动态过滤信息 【方案三】
                      // p_filter_temp_Obj_add(rw_list_obj_json,2);  //增加动态过滤信息
                      
                    }

                   

                    break;
                  //   }

                   
               
             }




              
                 }

              
              }
                  
              
       
          }
      }
      
      
  }


if(ft){
  fz=false;
}


/****总共2秒清除  5轮****/
//for_clear_div_main(20,0.1); 
//p_for_clear_div_main(10,0.1);

}

}
 
  
 /*******
 * 寻找下一页目标
 */
function rw_next(){

  

  if(p_Search_element_contains(1,["赚更多转账红包","红包","更多任务"]) ){
      
//矫正位置  start
if(UImain_txt_correct("更多任务",1,9)){
  console.info("更多任务切换-矫正了");
 // toast("进入矫正,更多任务切换界面");
//  sleep(2000);
 }
//矫正位置  end


let o_next;//点击下一页
if(p_Search_element_contains(1,["赚更多转账红包","红包","更多任务"]) ){
  //toast("fdsfds");
       o_next=className("android.view.View").text("更多任务").enabled(true).findOnce();
      if(!(o_next && o_next.text()=="更多任务")){
          o_next=className("android.widget.TextView").text("更多任务").enabled(true).findOnce();
      }
      if(!(o_next && o_next.text()=="更多任务")){
        o_next=className("android.widget.Button").text("更多任务").enabled(true).findOnce();
      }
      if(o_next && o_next.text()=="更多任务"){
          click(o_next.bounds().centerX(),o_next.bounds().centerY());
      }
 }

}

}


/*******
 * 任务过滤器
 *  
 *   防止执行不需要执行的任务
 *   
 */
function  p_filter_rwobj(o){
   
    if(filter_arr.indexOf(o)>-1){
        return true;
    }else{
        return false;
    }
  }
  
  
  
  /*******
   * 清除遮罩层  
   *   【循环次数】
   * n：次数
   * s: 停留时间
   */
  function for_clear_div_main(n,s){
      for(let i=0;i<n;i++){
       console.info("清楚遮罩层"+(i+1)+"轮"+",并且每轮"+s+"秒");
          clear_div_main();
          sleep(s*1000);
      }
   }
    
   //clear_div_main();
   /*******
   * 遮罩层
   * 
   */
  function  clear_div_main(){
      let clear_div;
      //console.log("a-111111111"+new Date());
       //特殊任务的奖励
      if(p_Search_element_contains(1,["你有转账红包可抽取"]) ){
        clear_div=className("android.view.View").text("你有转账红包可抽取").enabled(true).findOnce();
        if(!(clear_div  && clear_div.text()=="你有转账红包可抽取")){
          clear_div=className("android.widget.TextView").text("你有转账红包可抽取").enabled(true).findOnce();
        }
        if(!(clear_div  && clear_div.text()=="你有转账红包可抽取")){
          clear_div=className("android.widget.Button").text("你有转账红包可抽取").enabled(true).findOnce();
        }
      
        if((clear_div  && clear_div.text()=="你有转账红包可抽取")){
          if(clear_div && clear_div.parent()  
          && clear_div.parent().children().length>0 ){
      
            click(clear_div.parent().child(clear_div.parent().children().length-1).bounds().centerX(),
            clear_div.parent().child(clear_div.parent().children().length-1).bounds().centerY());
            sleep(800);
          }
        }
      }


      //任务完成后的奖励
      if(p_Search_element_contains(1,["恭喜获得","立即使用"]) ){
        clear_div=className("android.view.View").text("立即使用").enabled(true).findOnce();
        if(!(clear_div  && clear_div.text()=="立即使用")){
          clear_div=className("android.widget.TextView").text("立即使用").enabled(true).findOnce();
        }
        if(!(clear_div  && clear_div.text()=="立即使用")){
          clear_div=className("android.widget.Button").text("立即使用").enabled(true).findOnce();
        }
      
        if((clear_div  && clear_div.text()=="立即使用")){
          if(clear_div && clear_div.parent() && clear_div.parent().parent() && clear_div.parent().parent().parent() && clear_div.parent().parent().parent().parent()
          && clear_div.parent().parent().parent().parent().children().length==2 ){
      
            click(clear_div.parent().parent().parent().parent().child(1).bounds().centerX(),
            clear_div.parent().parent().parent().parent().child(1).bounds().centerY());
            sleep(800);
          }
        }
      }
 
 
  }
   
   
    //任务类型检测
  function p_if_rwtype_detector(n,s){
    let ft_type="qt_0";  //默认：移除任务
    let s_type=true;
    let m;
    for(let i=0;i<n;i++){
        m=i;
        if((p_Search_element_contains(1,["阅读赚","广告","关闭"]))){
          //浏览文章   阅读赚
          ft_type="ydz_0";
          break;
          }else  if(p_Search_element_contains(1,["广告","关闭"])){
            //阿里妈妈，【视频广告与滑动任务广告】
            ft_type="tb_0";
            s_type=false;
            break;
        }else if(p_Search_element_contains(1,["好礼享不停","点击订阅店铺"])){
             //淘宝关注，【关注店铺广告】
             ft_type="tb_1";
             s_type=false;
             break;
        }else if(p_Search_element_contains(1,["好礼享不停","入会好礼享不停"])){
          //淘宝关注，【关注店铺广告】   点击 入会好礼享不停 按钮
          ft_type="tb_2";
          s_type=false;
          break;
        }else if(p_Search_element_contains(1,["返回","对不起，您的访问请求过于频繁，暂时无法处理您的请求，请您等待一段时间后再来访问，感谢您的支持"])){
            ft_type="error_0";
            s_type=false;
            break;
        }else if(p_Search_element_contains(1,["每日任务","[点击广告]浏览后即可完成"])){
          //每日任务，点击广告  【出现位置：天天抢神券】
          ft_type="mrrw_click_0";
          s_type=false;
          break;
        }else if(p_Search_element_contains(1,["点击任务进度","0/3"])){
          //点击任务进度  0/3  三次点击任务  【出现位置：天天抢神券】
          ft_type="djrwjd_click_0";
          s_type=false;
          break;
        }else if(p_Search_element_contains(1,["点击任务进度","0/2"])){
          //点击任务进度  0/2  2次点击任务  【出现位置：天天抢神券】
          ft_type="djrwjd_click_1";
          s_type=false;
          break;
      }else if(p_Search_element_contains(1,["点击任务进度","0/1"])){
          //点击任务进度  0/1  1次点击任务  【出现位置：天天抢神券】
          ft_type="djrwjd_click_2";
          s_type=false;
          break;
      }else if(p_Search_element_contains(1,["逛一逛5秒得奖励"])){
        //逛一逛5秒得奖励  【出现位置：天天抢神券】
        ft_type="gygjmdjl_tl_0";
        s_type=false;
        break;
       }else if(p_Search_element_contains(1,["逛一逛15秒得奖励"])){
        //逛一逛15秒得奖励  【出现位置：天天抢神券】
        ft_type="gygjmdjl_tl_1";
        s_type=false;
        break;
       }else if(p_Search_element_contains(1,["每日福利","内容准备中","刷新"])){
        //没有相关任务信息，无效任务 【出现位置：天天抢神券】
        ft_type="error_1";
        s_type=false;
        break;
       }else if(p_Search_element_contains(1,["卡牌玩家","卡册"])){
        //月月赚   抽卡兑0元奖品
        ft_type="ts_yyz_kpwj_0";
        s_type=false;
        break;
       }else if(p_Search_element_contains(1,["机票","出行"])){
        //月月赚   完成一次急迫查询
        ft_type="ts_yyz_cxjp_0";
        s_type=false;
        break;

       }
      /****else if(p_Search_element_contains(1,["商品展示由阿里妈妈提供技术支持"]) && !p_Search_element_contains(1,["帮助中心"]) ){
        //阿里妈妈，【视频广告与滑动任务广告】 
        //【只能确定为阿里妈妈提供任务，需要再通过细分判断条件 判断是否为滑动任务、视频任务、其他任务】
        //使用推荐：该判断条件需要放到最后方，已保障更细分条件先判断优先级
        ft_type="tb_0";
        s_type=false;
        break;
       }****/
        //点击广告任务
  
        //点击商品任务
  
        //无效异常任务
  
  
        sleep(s*1000);//每次停留时间
    }
  
    //补充停留时间
    if((n-m)>0  && s_type){
     sleep((n-m)*s*1000);//
    }
  
    return ft_type;
  }
   
   
    /*******
    * 清除遮罩层  
    *   【循环次数】
    * n：次数
    * s: 停留时间
    */
    function p_for_clear_div_main(n,s){
     for(let i=0;i<n;i++){
     
         p_clear_div_main();
         sleep(s*1000);
     }
   }
   
   /********
   *【公共通用方法】
   *    清除遮罩层
   * 
   * 清除一个通用的遮罩层方法
   * 
   */
   function  p_clear_div_main(){
       /*****进入前的问题****/
      // console.log("p-11111111111"+new Date());
       let  clear_div=className("android.widget.Button").text("拒绝").enabled(true).findOnce();
       if(clear_div  &&  clear_div.text()=="拒绝"){
      // toast("找到了"+aaa.bounds().right);
    
       click(clear_div.bounds().centerX(),clear_div.bounds().centerY());
       sleep(2000);
       }else{
      // toast("找不到");
       }
    //   console.log("p-22222222222"+new Date());
       if(p_Search_element_contains(1,["发送以下消息","取消","好的","拒绝，不再询问"])){
        clear_div=className("android.widget.Button").text("拒绝，不再询问").enabled(true).findOnce();
        if(clear_div  &&  clear_div.text()=="拒绝，不再询问"){
       // toast("找到了"+aaa.bounds().right);
         
        click(clear_div.bounds().centerX(),clear_div.bounds().centerY());
        sleep(2000);
        }else{
       // toast("找不到");
        }
       }
     //  console.log("p-33333333333"+new Date());
       if(p_Search_element_contains(1,["发送以下消息","取消","好的"])){
       clear_div=className("android.widget.Button").text("取消").enabled(true).findOnce();
       if(clear_div  &&  clear_div.text()=="取消"){
      // toast("找到了"+aaa.bounds().right);
      
       click(clear_div.bounds().centerX(),clear_div.bounds().centerY());
       sleep(2000);
       }else{
      // toast("找不到");
       }
      }
  
    //  console.log("p-444444444444444"+new Date());
      if(p_Search_element_contains(1,["开启定位服务权限",""])){
        clear_div=className("android.widget.TextView").text("").enabled(true).findOnce();
        if(!(clear_div  && clear_div.text()=="")){
           clear_div=className("android.view.View").text("").enabled(true).findOnce();
        }
        if((clear_div  && clear_div.text()=="")){
    
           click(clear_div.bounds().centerX(),clear_div.bounds().centerY());
           sleep(2000);
        }
      }
  
    //  console.log("p-55555555555555555"+new Date());
      if(p_Search_element_contains(1,["开启地理位置权限",""])){
        clear_div=className("android.widget.TextView").text("").enabled(true).findOnce();
        if(!(clear_div  && clear_div.text()=="")){
           clear_div=className("android.view.View").text("").enabled(true).findOnce();
        }
        if((clear_div  && clear_div.text()=="")){
           
           click(clear_div.bounds().centerX(),clear_div.bounds().centerY());
           sleep(2000);
        }
    }
  
   // console.log("p-6666666666666"+new Date());
      //
      if(p_Search_element_contains(1,["开启地理位置权限","请在设置中，打开支付宝位置权限开关",""])){
        clear_div=className("android.widget.TextView").text("").enabled(true).findOnce();
        if(!(clear_div  && clear_div.text()=="")){
           clear_div=className("android.view.View").text("").enabled(true).findOnce();
        }
        if((clear_div  && clear_div.text()=="")){
           
           click(clear_div.bounds().centerX(),clear_div.bounds().centerY());
           sleep(2000);
        }
      }
    //  console.log("p-777777777777777"+new Date());
      //支付宝小程序的更新提示
      if(p_Search_element_contains(1,["更新提示","新版本已经准备好，是否重启应用？","取消","确定"])){
        clear_div=className("android.widget.TextView").text("取消").enabled(true).findOnce();
        if(!(clear_div  && clear_div.text()=="取消")){
           clear_div=className("android.view.View").text("取消").enabled(true).findOnce();
        }
        if(!(clear_div  && clear_div.text()=="取消")){
            clear_div=className("android.widget.Button").text("取消").enabled(true).findOnce();
         }
        if((clear_div  && clear_div.text()=="取消")){
          
           click(clear_div.bounds().centerX(),clear_div.bounds().centerY());
           sleep(2000);
        }
       }
     //  console.log("p-88888888888"+new Date());
  
   
   }
    
   
   
   
    /******
     * 获取任务执行清单的对象
     */
    function  p_hq_rw_Obj_init(rw_t_arr){
      let depth_obj;  //任务对应depth层信息
      for(var z=0;z<rw_t_arr.length;z++){
          let rw_list=className("android.view.View").text(""+rw_t_arr[z]).enabled(true).find();
          if(!(rw_list && rw_list.length>0)){
             rw_list=className("android.widget.TextView").text(""+rw_t_arr[z]).enabled(true).find();
          }
          if(rw_list && rw_list.length>0){
              /****优化：因部分任务签到的信息，导致无法具体定位到任务清单位置  采用取第2个位置的信息为优选****/
              if(rw_list.length>1){
                  depth_obj=rw_list[rw_list.length-1];
              }else if(rw_list.length>0){
                  depth_obj=rw_list[0];
              }else{
                  depth_obj;
              }
              break;
          }   
      }
      //toast("depth值:"+depth_v);
      return depth_obj;
   }
  
  
  
   /******
  * 【公共方法】
  * 动态任务过滤器
  * t:  Json格式正文信息【如：{name:"任务标题",jl:"奖励信息",ms:"描述"}】
  * m: 1：全量  2：去重
  *     信息增量
  * 
  * (方案1组合)
  */
  function  p_filter_temp_Obj_add(t,m){  
     // filter_temp_arr[t]=1;
     let z=true;
     if(m && m==2){
     //去重的方式
     if(JSON.stringify(filter_temp_Obj).indexOf(JSON.stringify(t)) == -1){
       console.info('该项不存在！');
     }else{
       console.info('该项已存在！');
       z=false;   
    //   filter_temp_Obj[JSON.stringify(filter_temp_Obj).indexOf(JSON.stringify(t))].count++
     }
   
    } 
     
    
     if(z){
         //fzt=true;
         filter_temp_Obj.push(t); //json新增数据
     }
     console.info(filter_temp_Obj);
    //  toast(filter_temp_arr[""+t+""]);
   }
   /******
   * 【公共方法】
   *  动态任务过滤器
   * t:Json格式正文信息【如：{name:"任务标题",jl:"奖励信息",ms:"描述"}】
   *   信息查询
   * 
   * (方案1组合)
   */
   function p_filter_temp_Obj_select(t){
     let fzt=false;
     //方案二：
     if(JSON.stringify(filter_temp_Obj).indexOf(JSON.stringify(t)) == -1){
       console.info('该项不存在！');
   }else{
       console.info('该项已存在！');
       fzt=true;
   }
   
     return fzt;
   }
   
  
  
  /********
  * 【公共方法】
  * 判定当前是否为手机运行中（recents状态下）应用清单界面，并且切换到recents状态
  * t: 核验的状态    1：精准   2.模糊【默认】   
  * hy_arr:核验当前页面中是否包含当前元素   数组方式
  * s: 每次验证的时间
  */
  function  ui_if_recents(t,hy_arr,s){
   let fzt=true;
  
   /****验证是否 进入recents状态*****/
   if(p_Search_element_contains(t,hy_arr)){
  
   }else{
     recents();
     sleep(s*1000);  //停留时间
   }
  
   return fzt;
  }
  
  
  
  /*********
  * 【任务方法】
  *   关注淘宝店铺任务
  * t: 核验的状态    1：精准   2.模糊【默认】   
  * hy_arr:核验当前页面中是否包含当前元素   数组方式  （如：["现有订阅店铺","好礼享不停","点击订阅店铺"]）  点击订阅店铺享好礼
  * rw_s:任务停留时间
  * qg_s:取关时间
  */
  function rw_taobao_gz(t,hy_arr,rw_s,qg_s){
   let  fzt=false;
  
   if(p_Search_element_contains(t,hy_arr)){
       //关注淘宝店铺任务
       console.info("关注淘宝店铺");
      
  
       //搜集所有点击相关按钮
       let dydp_but=className("android.view.View").text("点击订阅店铺").enabled(true).findOnce();
       if(!(dydp_but && dydp_but.text()=="点击订阅店铺")){
         dydp_but=className("android.widget.TextView").text("点击订阅店铺").enabled(true).findOnce();
       }
  
       if(!(dydp_but && dydp_but.text()=="点击订阅店铺")){
           dydp_but=className("android.view.View").text("点击订阅店铺享好礼").enabled(true).findOnce();
           if(!(dydp_but && dydp_but.text()=="点击订阅店铺享好礼")){
               dydp_but=className("android.widget.TextView").text("点击订阅店铺享好礼").enabled(true).findOnce();
           }
       }
  
  
  
       if((dydp_but && dydp_but.text()=="点击订阅店铺")){
            //第一场景
         click(dydp_but.bounds().centerX(),dydp_but.bounds().centerY());
         sleep(rw_s*1000);
       
         fzt=true;//完成关注任务
  
         //取关任务
         dydp_but=className("android.view.View").text("已关注").enabled(true).findOnce();
         if(!(dydp_but && dydp_but.text()=="已关注")){
         dydp_but=className("android.widget.TextView").text("已关注").enabled(true).findOnce();
        }
        if((dydp_but && dydp_but.text()=="已关注")){
         click(dydp_but.bounds().centerX(),dydp_but.bounds().centerY());
         sleep(qg_s*1000);
         }
       }else if((dydp_but && dydp_but.text()=="点击订阅店铺享好礼")){
           //第二场景
           click(dydp_but.bounds().centerX(),dydp_but.bounds().centerY());
           sleep(rw_s*1000);
         
           fzt=true;//完成关注任务
  
           //取关任务
           dydp_but=className("android.view.View").text("已关注").enabled(true).findOnce();
           if(!(dydp_but && dydp_but.text()=="已关注")){
           dydp_but=className("android.widget.TextView").text("已关注").enabled(true).findOnce();
          }
          if((dydp_but && dydp_but.text()=="已关注")){
           click(dydp_but.bounds().centerX(),dydp_but.bounds().centerY());
           sleep(qg_s*1000);
           }
         }
  
  
     }
  
     return fzt;
  }
  
   
  
/*********
 * 【任务执行器】
 * 任务滑动的操作步骤(无法获取头部提示信息，采用固定次数来完成)
 * n：执行轮次
 * s：每次间隔停留时间
 * hd_arr:验证滑动操作的关键词
 * 
 * 
 * 【针对多商品的任务】
 * 基于多元素核验
 */
function execute_rw_shop_slide(n,s,hd_arr){

  //执行滑动操作
  for(let i=0;i<n;i++){
    //设置  hd_arr=["商品展示由阿里妈妈提供技术支持"]
    if(p_Search_element_contains(1,hd_arr)){
      if(p_Search_element_contains(2,["¥"])){//判断存在相应的商品信息，进行滑动操作
     if(i%2==0){
      simulator_move(600,2);
     }else{
      simulator_move(600,1);
     }
     }
    }
    sleep(s*1000);//每轮停留时间
  }

  
   sleep(1000);
  //执行关闭操作
   if(p_Search_element_contains(1,hd_arr)){
    let a1,a2;
     a1=className("android.view.ViewGroup").enabled(true).findOnce();
     a2=className("com.uc.webview.export.WebView").enabled(true).findOnce();
     if(a1 && a2 && a1.className()=="android.view.ViewGroup" && a2.className()=="com.uc.webview.export.WebView"){
      let close_but=className("android.widget.FrameLayout").desc("关闭").enabled(true).findOnce();
       if(close_but  && close_but.desc()=="关闭"){
        click(close_but.bounds().centerX(),close_but.bounds().centerY());
       }else{
        //防止找不到点击，通过固定位置来
        click((device.width/10)*9,((device.height/20)*1.5-(0.4*(((device.height / device.width))- Math.floor(device.height / device.width))*device.height)));
               
       }
     }
   }
}
  
  
  
  /****【任务执行器】
  * 任务滑动的操作步骤
  * 
  * 基于多元素核验
  * 
  * *****/
  function execute_rw_slide(){
   let  fzt=true; /****方法执行状态****/
  
  
  let ll_zt=true;
  let hl_i=0;
  
  /****【循环保险丝功能】*****/
  let slide_rw_for_Zt=true;  //获取的总任务清单，循环是否有效被执行    
  let slide_rw_fow_v_fz=5;     //循环10次被无效执行，结束整体本任务执行   【阀值    固定】
  let slide_rw_fow_v_sl=slide_rw_fow_v_fz;     //循环10次被无效执行，结束整体本任务执行   【计数器  变化】
  /****【循环保险丝功能】*****/
  
  
  
  
  while(ll_zt){
    slide_rw_for_Zt=true;
  
  
      sleep(800);
  
      //已获得奖励
       
  
      if(p_Search_element_contains(1,["广告","已获得奖励","关闭"])){
        //进入关闭通道
        toast("进入关闭通道了");
        //关闭按钮
       let  stop_text=className("android.widget.TextView").text("关闭").enabled(true).findOnce();
       if(!(stop_text  && stop_text.text()=="关闭")){
        stop_text=className("android.view.View").text("关闭").enabled(true).findOnce();
       }
  
  
       if((stop_text  && stop_text.text()=="关闭")){
        sleep(1000);
        click(stop_text.bounds().centerX(),stop_text.bounds().centerY());
        ll_zt=false;
       }
  
      }else{
        //进入再滑动通道
        //toast("滑动通道");
        
        
        /****判断存在关闭按钮****/
        if(p_Search_element_contains(1,["广告","关闭"])){
          /****代表需要正常滑动****/
         // toast("当前滑动次数："+(hl_i+1));
          if(hl_i%2==0){
              simulator_move(800,2);
           }else{
              simulator_move(800,1);
           }
           hl_i++;
  
           slide_rw_for_Zt=false; /***【有效执行】  保险丝重置*****/
           slide_rw_fow_v_sl=slide_rw_fow_v_fz;
  
  
        }else{
         /*****找不到对应滑动需求，判断其他情况*****/
          /****结束循环*****/
  
        /****
          * 15秒最新任务出错情况
          * 【判断任务失败 条件1】任务未完成 View
          * 【判断任务失败 条件2】您需要点击1个商品并完成15s浏览才能领取奖励   View
          * 【重启任务条件 后续执行】继续完成任务  View
          ******/
        if(p_Search_element_contains(1,["对不起，您的访问请求过于频繁，暂时无法处理您的请求，请您等待一段时间后再来访问，感谢您的支持"])){
        
          let eixt_view=className("android.view.View").text("返回").enabled(true).findOnce();
          ll_zt=false;
         if(eixt_view && eixt_view.text()=="返回"){
          click(eixt_view.bounds().centerX(),eixt_view.bounds().centerY());
         }else{
           /*****也存在没有返回按钮，但是需要退出的情况。 需要通过左上角的返回按钮，或者直接接切换回本身任务界面***/ 
         }
          
          
        } 
          
        }
  
  
      }
  
       /*****循环保险丝功能**** */
       if(slide_rw_for_Zt){
           slide_rw_fow_v_sl--;   /***计数器启用****/
         if(slide_rw_fow_v_sl<0){
           /*****执行保险丝  跳出循环执行  【结束整体循环任务】*****/
           sleep(2000);
          // toast("触发（滑动）保险丝结束");
           throw new Error("自动异常");
  
           ll_zt=false;
           fzt=false;
           break;
          }
          sleep(2500);
          toast("（滑动）保险丝计数："+slide_rw_fow_v_sl);
          
       }
  
    }
  
    return fzt;
  }
  
  
  
  /*****
   * 【公共方法】
   *    在手机所有运行的程序，寻找指定的应用打开
   * 
   * t:  指定的应用名称    string
   * z:  移除方向   1：从左向右滑动  默认   2：从右向左滑动
   * s:  停留时间
   * 方案一
   * *****/
  function   seek_app_All(t,z,s){
     let  fzt=false; /****方法执行状态****/
   
     let  zt=true;          /*****循环控制器*****/
     let  delete_zt=false;  /****recents()控制器******/
     /****【循环保险丝功能】*****/
     let romve_rw_for_Zt=true;  //获取的总任务清单，循环是否有效被执行    
     let romve_rw_fow_v_fz=3;     //循环10次被无效执行，结束整体本任务执行   【阀值    固定】
     let romve_rw_fow_v_sl=romve_rw_fow_v_fz;     //循环10次被无效执行，结束整体本任务执行   【计数器  变化】
     /****【循环保险丝功能】*****/
   
     let phone_rw_list_l;  //任务清单变量
      
      
     console.info("进入移除任务-主函数");
   
   
     //分支1-确保没有新删除任务
     //s 停留时间  不断去移除淘宝不需要的应用
     for(let zzz=0;zzz<parseInt(s);zzz++){
       console.info("打开应用的删除"+(zzz+1)+"次");
     zt=true;
     while(zt){
       delete_zt=false;
       /***进入删除循环体****/
       if(!p_Search_element_contains(1,recents_zt_arr)){
         /*****判定是否在recents状态下，必须保障在recents状态下****/
         recents();
        }
        sleep(1000);
   
         //服务总清单
         /********/
        if(recents_id_v && recents_id_v.length>0){
            phone_rw_list_l=id(""+recents_id_v).className("android.widget.TextView").depth(recents_depth_v).enabled(true).find();
         }else{
            phone_rw_list_l=className("android.widget.TextView").depth(recents_depth_v).enabled(true).find();
         }
   
         if(!(phone_rw_list_l  && phone_rw_list_l.length>0)){
           if(recents_id_v && recents_id_v.length>0){
             phone_rw_list_l=id(""+recents_id_v).className("android.view.View").depth(recents_depth_v).enabled(true).find();
          }else{
             phone_rw_list_l=className("android.view.View").depth(recents_depth_v).enabled(true).find();
          }
         }
   
   
         
         if(phone_rw_list_l  && phone_rw_list_l.length>0){
           for(let i=0;i<phone_rw_list_l.length;i++){
               /*****过滤不可移除任务****/
               if(p_if_rw_error(phone_rw_list_l[i].text(),[""+t])){
                 //不可执行任务
               }else{
                 //移除任务
                 if(recents_romve_app_name(""+phone_rw_list_l[i].text(),1,recents_zt_arr,0.5,2,z)){
                   //移除一次后，新获取
                   delete_zt=true;
                   break;
                 }else{
                 }
               }
           }
         }
   
   
         if(p_Search_element_contains(1,recents_zt_arr)){
         if(!delete_zt ){
           //无删除,结束循环体
           zt=true;
           break;
         }
        }
     }
   
     sleep(500);
   }
   
   
     //分支2-回到原应用，并且停留相应时间
     zt=true;
   
   
   
     while(zt){
         romve_rw_for_Zt=true; //启动保险丝
   
         if(!p_Search_element_contains(1,recents_zt_arr)){
           /*****判定是否在recents状态下，必须保障在recents状态下****/
           recents();
          }
   
   
            sleep(1000);
        
            if(p_Search_element_contains(1,[""+t])){//判定是否存在原界面元素
          //   sleep(s*1000);//完成停留时间任务
   
            
            if(recents_click_app_name(""+t,1,recents_zt_arr,0.5,2)){
             //找到原本的界面，并且进入界面
             fzt=true;
             zt=false;  //结束运行
             romve_rw_for_Zt=false;  /***有效执行  保险丝重置** */
             romve_rw_fow_v_sl=romve_rw_fow_v_fz;
            }else{
             //未找到原界面
            
            }
           }
   
   
     
    /*****循环保险丝功能**** */
    if(romve_rw_for_Zt){
     romve_rw_fow_v_sl--;   /***计数器启用****/
     if(romve_rw_fow_v_sl<0){
       /*****执行保险丝  跳出循环执行  【结束整体循环任务】*****/
     //  sleep(2000);
      // toast("触发（指定应用）保险丝结束");
       throw new Error("自动异常");//手动异常
  
       zt=false;
       break;
     }
   
     sleep(2500);
    // toast("（指定应用）保险丝计数："+romve_rw_fow_v_sl);
   
     }
   
   
   
   }
   
   
    return fzt;
   }
  
  
  
  
  /********
  * 【公共方法】
  *    任务异常过滤器
  *  t  待验证的信息
  *  no_app_list:  临时停止移除的应用清单信息    数组类型
  *   
  */
  function  p_if_rw_error(t,no_app_list){
   let app_cleanAll_error_arr=["支付宝","Auto.js","微信","无障碍","设置","QQ","智狗管家"]; /****防止被清除应用  ***/
    let fzt=false;
    if(app_cleanAll_error_arr.indexOf(t)>-1  ){
        fzt=true;
    }else if(no_app_list && no_app_list.indexOf(t)>-1){
        fzt=true;
    }
   return fzt;
  }
  
  
  /*********
  * 【公共方法】
  *   recents状态下，移除  指定的应用名称
  *  name：移除的app名称
  *  t: 核验的状态    1：精准   2.模糊【默认】   
  *  hy_arr:核验当前页面中是否包含当前元素   数组方式
  *  s: 每次验证的时间
  *  c: 最高频次   0：无限次   【防止未找到元素出现堵塞】
  *  fx: 移除模式  1:向上移除【默认】    2：向右移除
  * 
  */
  function recents_romve_app_name(name,t,hy_arr,s,c,fx){
   let fzt=false;
   let zt=true; //循环体
   let obj;  //寻找name 对象
   let i=0;  //计数器
   while(zt){
       i++;
       //p_Search_element_contains(1,["分屏模式"])
       if(!p_Search_element_contains(t,hy_arr)){
           /*****判定是否在recents状态下，必须保障在recents状态下****/
           recents();
       }
  
       sleep(800);
       obj=className("android.widget.TextView").text(""+name).enabled(true).findOnce();
       if(!(obj && obj.text()==(""+name))){
           /***未找到对象，通过其他来寻找**/
           obj=className("android.view.View").text(""+name).enabled(true).findOnce();
       }
  
       console.info("移除寻找目标名称："+name);
       if(obj && obj.text()==(""+name)){
           /***保障找到合适目标****/
           if(p_Search_element_contains(t,hy_arr)){
               console.info("移除目标操作");
              if(fx && fx==2){
               console.info("向右移除操作");
               fzt=p_rwlist_swipe_right(obj.bounds().left,obj.bounds().centerY(),(device.height/10)*0.7);//向右移除
              }else{
               console.info("向上移除操作");
               fzt=p_rwlist_swipe_up(obj.bounds().centerX());  //保障移除成功 向上移除
              }
               if(fzt){
                   /****成功后，退出循环体****/
                   fz=true;
                   break;
               }
           }
       }
  
       if(c==0){
           //无效循环，只能通过其他途径禁止
           console.info("异常退出移除方法recents_romve_app_name()无限循环："+i);
       }else if(c<=i){
           console.info("异常退出移除方法recents_romve_app_name()："+i);
           //启动阀值
           fz=true;
           break;
       } 
     
       sleep(s*1000);  //每次的间隔停留时间
  
   }
   return fzt;
  }
  
  
  
  
  /*********
  * 【公共方法】
  *   recents状态下，点击打开  指定的应用名称
  *  name：移除的app名称
  *  t: 核验的状态    1：精准   2.模糊【默认】   
  *  hy_arr:核验当前页面中是否包含当前元素   数组方式
  *  s: 每次验证的时间
  *  c: 最高频次   0：无限次   【防止未找到元素出现堵塞】
  * 
  
  (来源： 【公共】移除某应用-基于多元素方案.js)
  */
  function recents_click_app_name(name,t,hy_arr,s,c){
   let fzt=false;
   let zt=true; //循环体
   let obj;  //寻找name 对象
   let i=0;  //计数器
   while(zt){
       i++;
       //p_Search_element_contains(1,["分屏模式"])
       if(!p_Search_element_contains(t,hy_arr)){
           /*****判定是否在recents状态下，必须保障在recents状态下****/
           recents();
       }
  
       sleep(1000);
       obj=className("android.widget.TextView").text(""+name).enabled(true).findOnce();
       if(!(obj && obj.text()==(""+name))){
           /***未找到对象，通过其他来寻找**/
           obj=className("android.view.View").text(""+name).enabled(true).findOnce();
       }
  
       console.info("recents状态打开寻找目标名称："+name);
       if(obj && obj.text()==(""+name)){
           /***保障找到合适目标****/
           if(p_Search_element_contains(t,hy_arr)){
               console.info("点击事件打开目标操作"+obj.bounds().centerX());
               if(obj.bounds() && obj.bounds().centerX()>0){
                 click(obj.bounds().centerX(),obj.bounds().centerY()+(device.height/10)*0.7);
               }else{
                 click(40,obj.bounds().centerY()+(device.height/10)*0.7);
               }
  
                 /***********
              * 验证是否退出了，窗口界面
              *   2023.10.31优化
              */
              /*****判定是否离开原界面****/
              if(ui_if_leave_interface(1,hy_arr,0.1,30)){
               fzt=true;
                /****成功后，退出循环体****/
                zt=false;
                break;
               }else{
                   zt=false;
                   break;
               } 
                  
           }
       }
  
       if(c==0){
           //无效循环，只能通过其他途径禁止
           console.info("异常打开方法recents_click_app_name()无限循环："+i);
       }else if(c<=i){
           console.info("异常打开方法recents_click_app_name()："+i);
           //启动阀值，关闭程序
           zt=false;
           break;
       } 
     
       sleep(s*1000);  //每次的间隔停留时间
  
   }
   return fzt;
  }
  
  
  
  
  /****
  * 【公共方法】移除任务列表任务  向上滑动移除任务
  *     x:  滑动的x坐标位置
  *     通过swipe移动
  * 【方案二】  
  * 
  * 向上移除方案
  *  *****/
  function p_rwlist_swipe_up(x){
   let fzt=true;
   /******
  *优化负数问题 
  */
  if(x>20){
  
  }else{
      x=40;
  }
   //向上移除方案
   swipe(x, (device.height/10)*6.5, x+5, (device.height/10)*0.8, 400);
  
  return fzt;
  }
  
  
  /****
  * 【公共方法】移除任务列表任务  向上滑动移除任务
  *     x:滑动的X坐标位置
  *     y:  滑动的Y坐标位置
  *     offset_Down:向下偏移
  *     通过swipe移动
  * 【方案二】  
  * 
  * 向右侧移除方案
  *  *****/
  function p_rwlist_swipe_right(x,y,offset_Down){
   let fzt=true;
   /******
  *优化负数问题 
  */
  if(x>20){
  
  }else{
      x=40;
  }
  
  if(y>20){
  
  }else{
      y=40;
  }
  
  if(offset_Down>=0){
     y=y+offset_Down;
  }
  
  
   //向右移除方案
   swipe(x, y, (device.width/10)*9, y+5, 400);
  
  return fzt;
  }
  
  
  
  
  /****
   * 【公共方法】
   *     搜索进入系统   输入指定搜索内容
   *   t：搜索的应用名称
   *   s:搜索后停留时长
   * 
   * 优化时间20231129 
   * 
   * 【方案一】
   * 针对支付宝 固定的能力来实现
   * ******/
  function  p_search_title(t,s){
      let  fzt=false; /****方法执行状态****/
  
   
      
           /****方案一：******/
           /*****
          let search_Text=className("android.widget.TextView").text("搜索服务或小程序").enabled(true).findOnce();
          if(search_Text  && search_Text.text()=="搜索服务或小程序"){
              //进入搜索界面
              click(search_Text.bounds().centerX(),search_Text.bounds().centerY());
              sleep(2000);
          }
          *******/
    
          /*****方案二********/
          let search_RelativeLayout=className("android.widget.RelativeLayout").desc("搜索框").enabled(true).findOnce();
          if(search_RelativeLayout  && search_RelativeLayout.desc()=="搜索框"){
            //进入搜索界面
            click(search_RelativeLayout.bounds().centerX(),search_RelativeLayout.bounds().centerY());
            sleep(2000);
          }
    
    
          //关闭按钮
          let stop_Text_but=className("android.widget.TextView").text("").enabled(true).findOnce();
          if(!(stop_Text_but  && stop_Text_but.text()=="")){
              stop_Text_but=className("android.view.View").text("").enabled(true).findOnce();
          }
  
          if(stop_Text_but  && stop_Text_but.text()==""){
              /****关闭按钮*****/
              click(stop_Text_but.bounds().centerX(),stop_Text_but.bounds().centerY());
              sleep(2000);
          }
      
          
      
          let search_Text_but=text("搜索").enabled(true).findOnce();
          if(search_Text_but  && search_Text_but.text()=="搜索"){
              console.info("输入搜索内容"); 
              //搜索框里面输入内容
              setText(0,""+t);  //第一个文本框输入  
              
              sleep(800);
              click(search_Text_but.bounds().centerX(),search_Text_but.bounds().centerY()); //搜索按钮
  
              sleep(s*1000); //停留时间
  
  
              /******
               * 打开应用目标
               */
  
               //第一层：采用常规信息点击打开应用
                search_Text_but=className("android.widget.TextView").text(""+t).enabled(true).findOnce();
               if(!(search_Text_but  && search_Text_but.text()==(""+t))){
                   search_Text_but=className("android.view.View").text(""+t).enabled(true).findOnce();
               }
               if(search_Text_but  && search_Text_but.text()==(""+t)){
                   console.info("正常打开小程序-"+t);
                   //找到相应的元素
                   click(search_Text_but.bounds().centerX(),search_Text_but.bounds().centerY());
                   sleep(2000);
                   fzt=true;//已成功，不需要尝试模式搜索
               }
           
           
               //第二层：采用异常模式   点击打开应用
               if(!fzt){
                 //  console.info("异常寻找APP");
                   search_Text_but=textContains(""+t).enabled(true).find();
                   for(let i=0;i<search_Text_but.length;i++){
                     //  console.info(["android.widget.TextView","android.view.View"].indexOf(search_Text_but[i].className()));
                     //  console.info(search_Text_but[i].text().trim()==(""+t));
                       
                       if(["android.widget.TextView","android.view.View"].indexOf(search_Text_but[i].className())>-1
                          && search_Text_but[i].text().trim()==(""+t)){
                           console.info("异常打开小程序-"+t);
                           click(search_Text_but[i].bounds().centerX(),search_Text_but[i].bounds().centerY());
                           sleep(2000);
                           fzt=true;//已成功，不需要尝试模式搜索
                       }
                       
                   }
           
               }
  
          }
      
          
        
          return fzt;
      }
  
  
  
  /*******
  * 【公共方法】
  * 通过多元素条件，来保障界面回退机制
  * t: 核验的状态    1：精准   2.模糊【默认】   
  * hy_arr:核验当前页面中是否包含当前元素   数组方式
  * s: 每次验证的时间
  * c: 最高频次   0：无限次   【防止未找到元素出现堵塞】
  * 
  */
  function  ui_rw_RollBACK(t,hy_arr,s,c){
     let fzt=false;
     let zt=true;
     let i=0; //计数器 
   
     while(zt){
       i++;
       console.info("执行回滚原界面"+i);
       p_for_clear_div_main(2,0.1);//总共0.5秒  执行2轮
   
  
       //防止一次无效验证，提前验证2轮 信息
       if(p_Search_element_contains(t,hy_arr)){
         //找到合适的界面元素
         console.info("执行回滚结束提前拦截0状态："+i);
         fzt=true;
         break;
       }
       //防止一次无效验证，提前验证2轮 信息
       if(p_Search_element_contains(t,hy_arr)){
         //找到合适的界面元素
         console.info("执行回滚结束提前拦截1状态："+i);
         fzt=true;
         break;
       }
  
  
       if(p_Search_element_contains(t,hy_arr)){
         //找到合适的界面元素
         console.info("执行回滚结束1状态："+i);
         fzt=true;
         break;
       }else{
         //未返回原界面，执行回退操作
         //考虑回退中降噪—清除过滤问题。
   
         //p_
   
   
        console.info("被执行了回滚_退出"+i);
         //回退操作
         back();
       }
   
       if(c==0){
         //无效循环，只能通过其他途径禁止
   
       }else if(c<=i){
         console.info("执行回滚结束2状态："+i);
         //启动阀值
         break;
       } 
   
       sleep(s*1000);
   
     }
   return fzt;
   }
  
  
  
   
  /***********
  * 【公共方法】
  * 判断是否有离开任务界面
  * t: 核验的状态    1：精准   2.模糊【默认】   
  * hy_arr:核验当前页面中是否包含当前元素   数组方式
  * s: 每次验证的时间
  * c: 最高频次   0：无限次   【防止未找到元素出现堵塞】
  * 
  */
  function  ui_if_leave_interface(t,hy_arr,s,c){
   let fzt=true;
   //let zt=true;
   let i=0; //计数器 
  
  while(p_Search_element_contains(t,hy_arr)){
  /********/
  i++;
  console.info("执行验证是否离开任务界面-当前次数："+i);
  
  sleep(s*1000);  //停留时间
  console.info("停留在原界面，未进入新页面。"+i+"次");
  //toast("停留在原界面，未进入新页面。"+i+"次");
  
  if(c==0){
   //无效循环，只能通过其他途径禁止
  
  }else if(c<=i){
   console.info("执行回滚结束2状态："+i);
   fzt=false;  //异常离开
   //启动阀值
   break;
  } 
  
  }
  
  return  fzt;
  }
  
  
  
  
     /**********
   * 【公共方法】
   * 
   *   核验元素的存在情况  
   * t: 核验的状态    1：精准   2.模糊【默认】   
   * hy_arr:核验当前页面中是否包含当前元素   数组方式
   * 
   * 返回值： true（存在）  false（不存在某个元素）
   * 
   */
     function p_Search_element_contains(t,hy_arr){
      
      let fzt=true;
      let hy_v_obj;
      let hy_w_obj;
      let hy_b_obj;
      let hy_S_obj;
      let hy_Img_obj;
      
  
      for(let i=0;i<hy_arr.length;i++){
          //  toast(hy_arr[i]);
  
          if(t && t==1){
            hy_v_obj=className("android.view.View").text(""+hy_arr[i]).enabled(true).findOnce();
            hy_w_obj=className("android.widget.TextView").text(""+hy_arr[i]).enabled(true).findOnce();
            hy_b_obj=className("android.widget.Button").text(""+hy_arr[i]).enabled(true).findOnce();
            hy_S_obj=className("android.widget.ScrollView").text(""+hy_arr[i]).enabled(true).findOnce();
            hy_Img_obj=className("android.widget.Image").text(""+hy_arr[i]).enabled(true).findOnce();
          }else{
            hy_v_obj=className("android.view.View").textContains(""+hy_arr[i]).enabled(true).findOnce();
            hy_w_obj=className("android.widget.TextView").textContains(""+hy_arr[i]).enabled(true).findOnce();
            hy_b_obj=className("android.widget.Button").textContains(""+hy_arr[i]).enabled(true).findOnce();
            hy_S_obj=className("android.widget.ScrollView").textContains(""+hy_arr[i]).enabled(true).findOnce();
            hy_Img_obj=className("android.widget.Image").textContains(""+hy_arr[i]).enabled(true).findOnce();
          }
  
           // sleep(3000);
            if((hy_v_obj && hy_v_obj.text().indexOf(""+hy_arr[i])>-1) || (hy_w_obj && hy_w_obj.text().indexOf(""+hy_arr[i])>-1)
            ||(hy_b_obj && hy_b_obj.text().indexOf(""+hy_arr[i])>-1) ||(hy_S_obj && hy_S_obj.text().indexOf(""+hy_arr[i])>-1)
            ||(hy_Img_obj && hy_Img_obj.text().indexOf(""+hy_arr[i])>-1) ){
            
            }else{
             //   toast("找不到么"+hy_arr[i]);
                fzt=false;
                break;
            }
  
  
  
        }
  
        return fzt;
  }
  
  
  
  
  
  /*******
  * 矫正方法
  * 【通过对象】
  *  寻找对象的位置
  * o:  寻找对象
  * shifting_top：  偏移上方    2【默认】
  * shifting_bottom：偏移下方   8.5【默认】
  * 
  */
  function  UImain_obj_correct(o,shifting_top,shifting_bottom){
     let  fzt=false; /****方法执行状态****/
     let  obj=o;     /****存储原本对象信息****/
  
     if(shifting_top>0){
  
     }else{
         shifting_top=2;
     }
  
     if(shifting_bottom>0){
  
     }else{
         shifting_bottom=8.5;
     }
  
     if(o && o.bounds() && o.bounds().bottom>=0){
      //有效传参
      let zt=true;   /****循环体****/
      let app_h=device.height;
      while(zt){
  
          sleep(1000);
          obj=className(""+o.className()).depth(o.depth()).indexInParent(o.indexInParent()).text(""+o.text()).enabled(true).findOnce();
  
        //  toast("bottom："+obj.bounds().bottom);
  
          if(obj && obj.bounds() && obj.bounds().bottom>=(app_h-(app_h/10)*shifting_top)){
              /****矫正中  向下找目标*****/
              fzt=true; 
              sml_move((device.width/10)*5, (device.height/10)*9, (device.width/10)*5, (device.height/10)*3, 600);
          }else if(obj && obj.bounds() && obj.bounds().bottom<=(app_h-(app_h/10)*shifting_bottom)){
               /****矫正中  向上找目标*****/
              fzt=true; 
              sml_move((device.width/10)*5, (device.height/10)*3, (device.width/10)*5, (device.height/10)*9, 600);
          }else{
              /****矫正结束****/
             // toast("可以进入么");
              zt=false;
              
          }
  
        //  sleep(2000);
      }
  
  
     }else{
       //无效传参
       fzt=false;
     }
  
     return fzt;
  }
  
  
  
  /*******
   * 矫正方法
   * 【通过文本内容】
   *  寻找对象的位置
   * o:  文本
  * shifting_top：  偏移上方    2【默认】
  * shifting_bottom：偏移下方   8.5【默认】
   */
  function  UImain_txt_correct(o,shifting_top,shifting_bottom){
      let  fzt=false; /****方法执行状态****/
      let  obj=o;     /****存储原本对象信息****/
   
     // toast("????");
     if(shifting_top>0){
  
     }else{
         shifting_top=2;
     }
  
     if(shifting_bottom>0){
  
     }else{
         shifting_bottom=8.5;
     }
  
      if(o && o.length>0){
       /***文本信息***/
       let zt=true;   /****循环体****/
       let app_h=device.height;
       while(zt){
   
         
           sleep(1000);
           obj=className("android.view.View").text(""+o).enabled(true).findOnce();
           if(!(obj && obj.text()==(""+o))){
               obj=className("android.widget.TextView").text(""+o).enabled(true).findOnce();
           }
   
           
           if(obj && obj.bounds() && obj.bounds().bottom>=(app_h-(app_h/10)*shifting_top)){
               /****矫正中  向下找目标*****/
               console.info("向下找目标"+obj.bounds().bottom+"|||||"+(app_h-(app_h/10)*shifting_top));
               fzt=true; 
               sml_move((device.width/10)*5, (device.height/10)*7.8, (device.width/10)*5, (device.height/10)*3, 600);
           }else if(obj && obj.bounds() && obj.bounds().bottom<=(app_h-(app_h/10)*shifting_bottom)){
                /****矫正中  向上找目标*****/
                console.info("向上找目标");
               fzt=true; 
               sml_move((device.width/10)*5, (device.height/10)*3, (device.width/10)*5, (device.height/10)*7.1, 600);
           }else{
               /****矫正结束****/
              // toast("可以进入么");
               zt=false;
               //fzt=false;
           }
   
         //  sleep(2000);
       }
      }else{
        //无效传参
        fzt=false;
      }
   
      return fzt;
   }
  
  
   
   
   /****
  * 公共类方法
  * 
  * 滑动方式  停留 控制器****/
  //t1 （停止时间） s滑动方式（1.上 2.下 3.左 4.右）
  function simulator_move(t1,s){
   //等待时间
   sleep(t1);
   /****
  if(s==1){
  //上
  sml_move(800, 500, 800, 1300, 1000);
  }else if(s==2){
  //下
  sml_move(400, 1200, 450, 500, 1000);
  
  }else if(s==3){
   //左
   sml_move(100, 900, 800, 900, 1000);
   
  }else if(s==4){
   //右
   sml_move(800, 900, 100, 900, 1000);
  }
  *****/
  if(s==1){
   /**上***/
   sml_move((device.width/10)*5, (device.height/10)*3, (device.width/10)*5, (device.height/10)*7, 400);
  }else if(s==2){
   /**下***/
   sml_move((device.width/10)*5, (device.height/10)*7, (device.width/10)*5, (device.height/10)*3, 400);
  
  }else if(s==3){
    /**左***/
    sml_move((device.width/10)*1.5, (device.height/10)*5, (device.width/10)*8, (device.height/10)*5, 400);
    
  }else if(s==4){
    /**右***/
    sml_move((device.width/10)*8, (device.height/10)*5, (device.width/10)*1.5, (device.height/10)*5, 400);
  }
  
  }
   
   
   //长距离测试
   //sml_move(400, 1800, 800, 230, 1000);
   //短距离测试
   //sml_move(400, 1000, 800, 600, 1000);
   function bezier_curves(cp, t) {
      cx = 3.0 * (cp[1].x - cp[0].x); 
      bx = 3.0 * (cp[2].x - cp[1].x) - cx; 
      ax = cp[3].x - cp[0].x - cx - bx; 
      cy = 3.0 * (cp[1].y - cp[0].y); 
      by = 3.0 * (cp[2].y - cp[1].y) - cy; 
      ay = cp[3].y - cp[0].y - cy - by; 
      
      tSquared = t * t; 
      tCubed = tSquared * t; 
      result = {
          "x": 0,
          "y": 0
      };
      result.x = (ax * tCubed) + (bx * tSquared) + (cx * t) + cp[0].x; 
      result.y = (ay * tCubed) + (by * tSquared) + (cy * t) + cp[0].y; 
      return result; 
   };
   
   //仿真随机带曲线滑动  
   //qx, qy, zx, zy, time 代表起点x,起点y,终点x,终点y,过程耗时单位毫秒
   function sml_move(qx, qy, zx, zy, time) {
      var xxy = [time];
      var point = [];
      var dx0 = {
          "x": qx,
          "y": qy
      };
   
      var dx1 = {
          "x": random(qx - 100, qx + 100),
          "y": random(qy , qy + 50)
      };
      var dx2 = {
          "x": random(zx - 100, zx + 100),
          "y": random(zy , zy + 50),
      };
      var dx3 = {
          "x": zx,
          "y": zy
      };
      for (var i = 0; i < 4; i++) {
   
          eval("point.push(dx" + i + ")");
   
      };
      log(point[3].x)
   
      for (let i = 0; i < 1; i += 0.08) {
          xxyy = [parseInt(bezier_curves(point, i).x), parseInt(bezier_curves(point, i).y)]
   
          xxy.push(xxyy);
   
      }
   
    //  log(xxy);
      gesture.apply(null, xxy);
   };
   
  
   //初始化
  function initializeData(){
  
    
     storage_name_key="2444717083@qq.com:智狗管家111111111Content";
     fx_ty=sto_base_select_fx_ty();
     recents_depth_v=sto_base_select_recents_depth_v();   /***depth的值情况*****/
     recents_id_v=sto_base_select_recents_id_v();      /****id的值情况****/
    /********* */
     recents_zt_arr=sto_base_select_recents_zt_arr();   //recents状态验证 关键词
  
     
  }
  
  
  //运行异常
  function run_error(){
    sto_run_rw_error_add(true);
  //  engines.stopAll();   //可结束所有 setInterval
  }
  
  //运行成功结果
  function run_success(){
    sto_run_rw_ty_add(true);
   // engines.stopAll();   //可结束所有 setInterval
  }
  
  
   //查询
  function  sto_base_select_recents_depth_v(){
    return pt_storage_get("recents_depth_v");
  }
  function  sto_base_select_recents_id_v(){
    return  pt_storage_get("recents_id_v");
  }
  function  sto_base_select_recents_zt_arr(){
    return pt_storage_get("recents_zt_arr");
  }
  function  sto_base_select_fx_ty(){
    return  pt_storage_get("recents_fx_ty");
  }
  //增加
  function  sto_base_add_recents_depth_v(v){
    return  pt_storage_add("recents_depth_v",v);
  }
  function  sto_base_add_recents_id_v(v){
    return  pt_storage_add("recents_id_v",v);
  }
  function  sto_base_add_recents_zt_arr(v){
    return   pt_storage_add("recents_zt_arr",v);
  }
  function  sto_base_add_fx_ty(v){
    return  pt_storage_add("recents_fx_ty",v);
  }
  //删除
  function  sto_base_delete_recents_depth_v(){
    console.info("清除storages中recents_depth_v信息");
    return  pt_storage_delete("recents_depth_v");
  }
  function  sto_base_delete_recents_id_v(){
    console.info("清除storages中recents_id_v信息");
    return  pt_storage_delete("recents_id_v");
  }
  function  sto_base_delete_recents_zt_arr(){
    console.info("清除storages中recents_zt_arr信息");
    return pt_storage_delete("recents_zt_arr");
  }
  function  sto_base_delete_fx_ty(){
    console.info("清除storages中recents_fx_ty信息");
    return  pt_storage_delete("recents_fx_ty");
  }
  
  function sto_run_rw_ty_select(){
    return  pt_storage_get("run_rw_ty");
  }
  function sto_run_rw_ty_add(v){
    return  pt_storage_add("run_rw_ty",v);
  }
  function sto_run_rw_ty_delete(){
    return  pt_storage_delete("run_rw_ty");
  }
  
  
  function sto_run_rw_error_select(){
    return  pt_storage_get("run_rw_error");
  }
  function sto_run_rw_error_add(v){
    return  pt_storage_add("run_rw_error",v);
  }
  function sto_run_rw_error_delete(){
    return  pt_storage_delete("run_rw_error");
  }
  
  
  /********
   * 【公共】添加本地信息
   *  key：key对象
   *  value:对应的值
   * 
   *  返回： true(成功)  false（失败）
   * 
   * 【平台侧信息】
   */
  function  pt_storage_add(key,value){
      let fzt=true;
      try{
      let storage = storages.create(storage_name_key);
      storage.put(key, value);
      }catch(err) {
          console.info(err.message);
          fzt=false;
      }
      return fzt;
  }
  
  /*******
   * 【公共】查询本地信息
   * 返回对应key的存储信息
   * key：key对象
   * 【平台侧信息】
   */
  function  pt_storage_get(key){
      let v="";
      try{
      let storage = storages.create(storage_name_key);
      if(storage.contains(""+key)){//判断是否存在相应信息
          v=storage.get(key);
      } 
      }catch(err) {
          console.info(err.message);
          v="error";
      }
      return v;
  }
  
  
  /******
   * 【公共】删除storage中指定的key信息
   * key: key对象
   * 【平台侧信息】
   */
  function pt_storage_delete(key){
      let fzt=true;
      try{
          storage.remove(key);  //删除对应 指定key
          if(storage.contains(key)){
              fzt=false;
          }
      }catch(err) {
          console.info(err.message);
          fzt=false;
      }
      return fzt;
  }
  
  /******
   * 【公共】清除storage所有信息
   * 
   * 【平台侧信息】
   */
  function pt_storage_deleteAll(){
      try{
          let storage = storages.create(storage_name_key);
          //移除该本地存储的所有数据
           storage.clear();
      }catch(err) {
          console.info(err.message);
      }
  }
  
  
  
  
  
  /*******
   * 【公共方法】
   *   收藏小程序
   * 
   * s: 停留时间    默认：1秒
   */
  function  p_app_zfb_collect_open(s){
    let fzt=false;
    if(s && s>0){
  
    }else{
        s=1;
    }
   if(p_Search_element_contains(1,[""])){
    let  click_button=className("android.view.View").text("").enabled(true).findOnce();
    if(!(click_button && click_button.text()=="")){
        click_button=className("android.widget.TextView").text("").enabled(true).findOnce();
    }
    if(!(click_button && click_button.text()=="")){
        click_button=className("android.widget.Button").text("").enabled(true).findOnce();
    }
    if(click_button && click_button.text()==""){
        click(click_button.bounds().centerX(),click_button.bounds().centerY());
    
        sleep(s*1000);
        fzt=true;
  
        click((device.width/10)*5,click_button.bounds().centerY()); //防止去掉收藏成功的遮罩层 【点击重点空白处 取消遮罩层】
  
    }
    
   }
  return fzt;
  
  } 



  /*****
 * 字符串中提取数字
 */
function extractNumbers(str) {
  let pattern = /\d+/g;
  let matches = str.match(pattern);
  return matches ? matches.map(Number) : [];
}